package controllers

import (
	"encoding/json"
	"strconv"
	"supershare/backend/models"
	"supershare/backend/utils"
	"time"

	"github.com/beego/beego/v2/core/logs"
	"github.com/beego/beego/v2/server/web"
)

// FinanceController 财务中心控制器
type FinanceController struct {
	web.Controller
}

// FinanceStatistics 财务统计数据
type FinanceStatistics struct {
	TotalRevenue     int64                            `json:"total_revenue"`     // 总收入（分）
	TodayRevenue     int64                            `json:"today_revenue"`     // 今日收入（分）
	YesterdayRevenue int64                            `json:"yesterday_revenue"` // 昨日收入（分）
	WeekRevenue      int64                            `json:"week_revenue"`      // 本周收入（分）
	MonthRevenue     int64                            `json:"month_revenue"`     // 本月收入（分）
	PaymentTypes     []models.PaymentTypeDistribution `json:"payment_types"`     // 支付方式分布
	OrderStatus      []models.OrderStatusDistribution `json:"order_status"`      // 订单状态分布
	RevenueByDay     []map[string]interface{}         `json:"revenue_by_day"`    // 每日收入趋势
	RevenueByStore   []map[string]interface{}         `json:"revenue_by_store"`  // 各门店收入分布
	RevenueByVenue   []map[string]interface{}         `json:"revenue_by_venue"`  // 各场地收入分布
}

// GetStatistics 获取财务统计数据
func (c *FinanceController) GetStatistics() {
	// 获取请求参数
	storeIdStr := c.GetString("store_id")
	startTimeStr := c.GetString("start_time")
	endTimeStr := c.GetString("end_time")

	var storeId int64
	var startTime, endTime int64
	var err error

	// 解析门店ID
	if storeIdStr != "" {
		storeId, err = strconv.ParseInt(storeIdStr, 10, 64)
		if err != nil {
			c.Data["json"] = utils.ResponseFail("门店ID格式错误")
			c.ServeJSON()
			return
		}
	}

	// 解析时间范围，如果未指定，默认为最近30天
	if startTimeStr != "" {
		startTime, err = strconv.ParseInt(startTimeStr, 10, 64)
		if err != nil {
			c.Data["json"] = utils.ResponseFail("开始时间格式错误")
			c.ServeJSON()
			return
		}
	} else {
		// 默认为30天前
		startTime = time.Now().AddDate(0, 0, -30).Unix()
	}

	if endTimeStr != "" {
		endTime, err = strconv.ParseInt(endTimeStr, 10, 64)
		if err != nil {
			c.Data["json"] = utils.ResponseFail("结束时间格式错误")
			c.ServeJSON()
			return
		}
	} else {
		// 默认为当前时间
		endTime = time.Now().Unix()
	}

	// 构建过滤条件
	filters := map[string]interface{}{
		"start_time": startTime,
		"end_time":   endTime,
	}
	if storeId > 0 {
		filters["store_id"] = storeId
	}

	// 获取财务统计数据
	stats, err := models.GetFinanceStatistics(filters)
	if err != nil {
		logs.Error("获取财务统计数据失败: %v", err)
		c.Data["json"] = utils.ResponseFail("获取财务统计数据失败")
		c.ServeJSON()
		return
	}

	// 获取支付方式分布
	paymentTypes, err := models.GetPaymentTypeDistribution(filters)
	if err != nil {
		logs.Error("获取支付方式分布失败: %v", err)
		c.Data["json"] = utils.ResponseFail("获取支付方式分布失败")
		c.ServeJSON()
		return
	}

	// 获取订单状态分布
	orderStatus, err := models.GetOrderStatusDistribution(filters)
	if err != nil {
		logs.Error("获取订单状态分布失败: %v", err)
		c.Data["json"] = utils.ResponseFail("获取订单状态分布失败")
		c.ServeJSON()
		return
	}

	// 获取每日收入趋势
	revenueByDay, err := models.GetRevenueByDay(filters)
	if err != nil {
		logs.Error("获取每日收入趋势失败: %v", err)
		c.Data["json"] = utils.ResponseFail("获取每日收入趋势失败")
		c.ServeJSON()
		return
	}

	// 获取各门店收入分布
	revenueByStore, err := models.GetRevenueByStore(filters)
	if err != nil {
		logs.Error("获取各门店收入分布失败: %v", err)
		c.Data["json"] = utils.ResponseFail("获取各门店收入分布失败")
		c.ServeJSON()
		return
	}

	// 获取各场地收入分布
	revenueByVenue, err := models.GetRevenueByVenue(filters)
	if err != nil {
		logs.Error("获取各场地收入分布失败: %v", err)
		c.Data["json"] = utils.ResponseFail("获取各场地收入分布失败")
		c.ServeJSON()
		return
	}

	// 构建返回数据
	result := FinanceStatistics{
		TotalRevenue:     stats.TotalRevenue,
		TodayRevenue:     stats.TodayRevenue,
		YesterdayRevenue: stats.YesterdayRevenue,
		WeekRevenue:      stats.WeekRevenue,
		MonthRevenue:     stats.MonthRevenue,
		PaymentTypes:     paymentTypes,
		OrderStatus:      orderStatus,
		RevenueByDay:     revenueByDay,
		RevenueByStore:   revenueByStore,
		RevenueByVenue:   revenueByVenue,
	}

	c.Data["json"] = utils.ResponseSuccess("获取成功", result)
	c.ServeJSON()
}

// GetTransactionList 获取交易记录列表
func (c *FinanceController) GetTransactionList() {
	// 获取分页参数
	page, _ := c.GetInt("page", 1)
	pageSize, _ := c.GetInt("pageSize", 10)

	// 获取过滤参数
	storeIdStr := c.GetString("store_id")
	startTimeStr := c.GetString("start_time")
	endTimeStr := c.GetString("end_time")
	paymentType := c.GetString("payment_type")
	transactionType := c.GetString("transaction_type")
	keyword := c.GetString("keyword")

	var storeId int64
	var startTime, endTime int64
	var err error

	// 解析门店ID
	if storeIdStr != "" {
		storeId, err = strconv.ParseInt(storeIdStr, 10, 64)
		if err != nil {
			c.Data["json"] = utils.ResponseFail("门店ID格式错误")
			c.ServeJSON()
			return
		}
	}

	// 解析时间范围
	if startTimeStr != "" {
		startTime, err = strconv.ParseInt(startTimeStr, 10, 64)
		if err != nil {
			c.Data["json"] = utils.ResponseFail("开始时间格式错误")
			c.ServeJSON()
			return
		}
	}

	if endTimeStr != "" {
		endTime, err = strconv.ParseInt(endTimeStr, 10, 64)
		if err != nil {
			c.Data["json"] = utils.ResponseFail("结束时间格式错误")
			c.ServeJSON()
			return
		}
	}

	// 构建过滤条件
	filters := map[string]interface{}{
		"keyword": keyword,
	}
	if storeId > 0 {
		filters["store_id"] = storeId
	}
	if startTime > 0 {
		filters["start_time"] = startTime
	}
	if endTime > 0 {
		filters["end_time"] = endTime
	}
	if paymentType != "" {
		filters["payment_type"] = paymentType
	}
	if transactionType != "" {
		filters["transaction_type"] = transactionType
	}

	// 获取交易记录列表
	transactions, total, err := models.GetTransactionList(page, pageSize, filters)
	if err != nil {
		logs.Error("获取交易记录列表失败: %v", err)
		c.Data["json"] = utils.ResponseFail("获取交易记录列表失败")
		c.ServeJSON()
		return
	}

	// 构建返回数据
	result := map[string]interface{}{
		"list":  transactions,
		"total": total,
		"page":  page,
		"size":  pageSize,
	}

	c.Data["json"] = utils.ResponseSuccess("success", result)
	c.ServeJSON()
}

// GetTransactionDetail 获取交易记录详情
func (c *FinanceController) GetTransactionDetail() {
	// 获取交易ID
	idStr := c.Ctx.Input.Param(":id")
	id, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil {
		c.Data["json"] = utils.ResponseFail("交易ID格式错误")
		c.ServeJSON()
		return
	}

	// 获取交易记录详情
	transaction, err := models.GetTransactionDetail(id)
	if err != nil {
		logs.Error("获取交易记录详情失败: %v", err)
		c.Data["json"] = utils.ResponseFail("获取交易记录详情失败")
		c.ServeJSON()
		return
	}

	if transaction == nil {
		c.Data["json"] = utils.ResponseFail("交易记录不存在")
		c.ServeJSON()
		return
	}

	c.Data["json"] = utils.ResponseSuccess("success", transaction)
	c.ServeJSON()
}

// ExportTransactions 导出交易记录
func (c *FinanceController) ExportTransactions() {
	// 获取过滤参数
	storeIdStr := c.GetString("store_id")
	startTimeStr := c.GetString("start_time")
	endTimeStr := c.GetString("end_time")
	paymentType := c.GetString("payment_type")
	transactionType := c.GetString("transaction_type")
	keyword := c.GetString("keyword")

	var storeId int64
	var startTime, endTime int64
	var err error

	// 解析门店ID
	if storeIdStr != "" {
		storeId, err = strconv.ParseInt(storeIdStr, 10, 64)
		if err != nil {
			c.Data["json"] = utils.ResponseFail("门店ID格式错误")
			c.ServeJSON()
			return
		}
	}

	// 解析时间范围
	if startTimeStr != "" {
		startTime, err = strconv.ParseInt(startTimeStr, 10, 64)
		if err != nil {
			c.Data["json"] = utils.ResponseFail("开始时间格式错误")
			c.ServeJSON()
			return
		}
	}

	if endTimeStr != "" {
		endTime, err = strconv.ParseInt(endTimeStr, 10, 64)
		if err != nil {
			c.Data["json"] = utils.ResponseFail("结束时间格式错误")
			c.ServeJSON()
			return
		}
	}

	// 构建过滤条件
	filters := map[string]interface{}{
		"keyword": keyword,
	}
	if storeId > 0 {
		filters["store_id"] = storeId
	}
	if startTime > 0 {
		filters["start_time"] = startTime
	}
	if endTime > 0 {
		filters["end_time"] = endTime
	}
	if paymentType != "" {
		filters["payment_type"] = paymentType
	}
	if transactionType != "" {
		filters["transaction_type"] = transactionType
	}

	// 导出交易记录
	excelData, err := models.ExportFinanceTransactions(filters)
	if err != nil {
		logs.Error("导出交易记录失败: %v", err)
		c.Data["json"] = utils.ResponseFail("导出交易记录失败")
		c.ServeJSON()
		return
	}

	// 设置响应头
	c.Ctx.Output.Header("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
	c.Ctx.Output.Header("Content-Disposition", "attachment; filename=transactions.xlsx")
	c.Ctx.Output.Header("Content-Transfer-Encoding", "binary")
	c.Ctx.Output.Header("Cache-Control", "must-revalidate")
	c.Ctx.Output.Header("Pragma", "public")

	// 输出Excel数据
	c.Ctx.Output.Body(excelData)
}

// GetSettlementList 获取结算记录列表
func (c *FinanceController) GetSettlementList() {
	// 获取分页参数
	page, _ := c.GetInt("page", 1)
	pageSize, _ := c.GetInt("pageSize", 10)

	// 获取过滤参数
	storeIdStr := c.GetString("store_id")
	startTimeStr := c.GetString("start_time")
	endTimeStr := c.GetString("end_time")
	status := c.GetString("status")
	keyword := c.GetString("keyword")

	var storeId int64
	var startTime, endTime int64
	var err error

	// 解析门店ID
	if storeIdStr != "" {
		storeId, err = strconv.ParseInt(storeIdStr, 10, 64)
		if err != nil {
			c.Data["json"] = utils.ResponseFail("门店ID格式错误")
			c.ServeJSON()
			return
		}
	}

	// 解析时间范围
	if startTimeStr != "" {
		startTime, err = strconv.ParseInt(startTimeStr, 10, 64)
		if err != nil {
			c.Data["json"] = utils.ResponseFail("开始时间格式错误")
			c.ServeJSON()
			return
		}
	}

	if endTimeStr != "" {
		endTime, err = strconv.ParseInt(endTimeStr, 10, 64)
		if err != nil {
			c.Data["json"] = utils.ResponseFail("结束时间格式错误")
			c.ServeJSON()
			return
		}
	}

	// 构建过滤条件
	filters := map[string]interface{}{
		"keyword": keyword,
	}
	if storeId > 0 {
		filters["store_id"] = storeId
	}
	if startTime > 0 {
		filters["start_time"] = startTime
	}
	if endTime > 0 {
		filters["end_time"] = endTime
	}
	if status != "" {
		statusInt, err := strconv.Atoi(status)
		if err == nil {
			filters["status"] = statusInt
		}
	}

	// 获取结算记录列表
	settlements, total, err := models.GetSettlementList(page, pageSize, filters)
	if err != nil {
		logs.Error("获取结算记录列表失败: %v", err)
		c.Data["json"] = utils.ResponseFail("获取结算记录列表失败")
		c.ServeJSON()
		return
	}

	// 构建返回数据
	result := map[string]interface{}{
		"list":  settlements,
		"total": total,
		"page":  page,
		"size":  pageSize,
	}

	c.Data["json"] = utils.ResponseSuccess("success", result)
	c.ServeJSON()
}

// GetSettlementDetail 获取结算记录详情
func (c *FinanceController) GetSettlementDetail() {
	// 获取结算ID
	idStr := c.Ctx.Input.Param(":id")
	id, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil {
		c.Data["json"] = utils.ResponseFail("结算ID格式错误")
		c.ServeJSON()
		return
	}

	// 获取结算记录详情
	settlement, err := models.GetSettlementDetail(id)
	if err != nil {
		logs.Error("获取结算记录详情失败: %v", err)
		c.Data["json"] = utils.ResponseFail("获取结算记录详情失败")
		c.ServeJSON()
		return
	}

	if settlement == nil {
		c.Data["json"] = utils.ResponseFail("结算记录不存在")
		c.ServeJSON()
		return
	}

	c.Data["json"] = utils.ResponseSuccess("success", settlement)
	c.ServeJSON()
}

// CreateSettlement 创建结算记录
func (c *FinanceController) CreateSettlement() {
	// 解析请求参数
	var params struct {
		StoreId     int64  `json:"store_id"`
		StartTime   int64  `json:"start_time"`
		EndTime     int64  `json:"end_time"`
		Amount      int64  `json:"amount"`
		Description string `json:"description"`
	}

	err := json.Unmarshal(c.Ctx.Input.RequestBody, &params)
	if err != nil {
		c.Data["json"] = utils.ResponseFail("参数解析失败")
		c.ServeJSON()
		return
	}

	// 参数验证
	if params.StoreId <= 0 {
		c.Data["json"] = utils.ResponseFail("门店ID不能为空")
		c.ServeJSON()
		return
	}

	if params.StartTime <= 0 || params.EndTime <= 0 {
		c.Data["json"] = utils.ResponseFail("结算时间范围不能为空")
		c.ServeJSON()
		return
	}

	if params.EndTime <= params.StartTime {
		c.Data["json"] = utils.ResponseFail("结束时间必须大于开始时间")
		c.ServeJSON()
		return
	}

	// 获取当前操作用户
	userId := c.GetSession("user_id")
	var userIdInt int64
	if userId != nil {
		userIdInt, _ = userId.(int64)
	}

	// 创建结算记录
	settlement := &models.Settlement{
		StoreId:     params.StoreId,
		StartTime:   params.StartTime,
		EndTime:     params.EndTime,
		Amount:      params.Amount,
		Status:      models.SettlementStatusPending, // 默认为待结算状态
		Description: params.Description,
	}
	settlement.CreatedBy = strconv.FormatInt(userIdInt, 10)
	settlement.UpdatedBy = strconv.FormatInt(userIdInt, 10)

	id, err := models.CreateSettlement(settlement)
	if err != nil {
		logs.Error("创建结算记录失败: %v", err)
		c.Data["json"] = utils.ResponseFail("创建结算记录失败")
		c.ServeJSON()
		return
	}

	// 获取创建后的结算记录
	newSettlement, _ := models.GetSettlementDetail(id)

	c.Data["json"] = utils.ResponseSuccess("新增结算记录成功", newSettlement)
	c.ServeJSON()
}

// UpdateSettlementStatus 更新结算记录状态
func (c *FinanceController) UpdateSettlementStatus() {
	// 解析请求参数
	var params struct {
		Id          int64  `json:"id"`
		Status      int    `json:"status"`
		Description string `json:"description"`
	}

	err := json.Unmarshal(c.Ctx.Input.RequestBody, &params)
	if err != nil {
		c.Data["json"] = utils.ResponseFail("参数解析失败")
		c.ServeJSON()
		return
	}

	// 参数验证
	if params.Id <= 0 {
		c.Data["json"] = utils.ResponseFail("结算ID不能为空")
		c.ServeJSON()
		return
	}

	// 获取当前操作用户
	userId := c.GetSession("user_id")
	var userIdInt int64
	if userId != nil {
		userIdInt, _ = userId.(int64)
	}

	// 更新结算记录状态
	err = models.UpdateSettlementStatus(params.Id, params.Status, params.Description, strconv.FormatInt(userIdInt, 10))
	if err != nil {
		logs.Error("更新结算记录状态失败: %v", err)
		c.Data["json"] = utils.ResponseFail("更新结算记录状态失败")
		c.ServeJSON()
		return
	}

	c.Data["json"] = utils.ResponseSuccess("更新结算记录状态成功", nil)
	c.ServeJSON()
}
